import { createStore } from 'vuex'
import { userApi } from '@/api/user'

export default createStore({
  // 状态
  state: {
    // 用户信息
    userInfo: null,
    // 是否已登录
    isLoggedIn: false,
    // 认证token
    token: null,
    // 加载状态
    loading: false,
    // 当前页面标题
    pageTitle: '惠学阁'
  },

  // 获取器
  getters: {
    // 获取用户信息
    getUserInfo: state => state.userInfo,
    
    // 获取登录状态
    getLoginStatus: state => state.isLoggedIn,
    
    // 获取用户角色
    getUserRole: state => state.userInfo?.userRole || state.userInfo?.role || 'USER',
    
    // 检查是否为管理员
    isAdmin: state => {
      const userInfo = state.userInfo
      return userInfo && (userInfo.role === 'ADMIN' || userInfo.userRole === 'ADMIN')
    },
    
    // 获取用户名
    getUsername: state => state.userInfo?.username || '',
    
    // 获取加载状态
    getLoading: state => state.loading,
    
    // 获取页面标题
    getPageTitle: state => state.pageTitle
  },

  // 同步修改状态的方法
  mutations: {
    // 设置用户信息
    SET_USER_INFO(state, userInfo) {
      state.userInfo = userInfo
      state.isLoggedIn = !!userInfo
      
      if (userInfo) {
        // 根据用户角色使用不同的存储键
        const storageKey = userInfo.userRole === 'ADMIN' ? 'adminUserInfo' : 'userUserInfo'
        localStorage.setItem(storageKey, JSON.stringify(userInfo))
      }
    },

    // 设置token
    SET_TOKEN(state, token) {
      state.token = token
      if (token) {
        // 根据用户角色使用不同的存储键
        const storageKey = state.userInfo?.userRole === 'ADMIN' ? 'adminToken' : 'userToken'
        localStorage.setItem(storageKey, token)
        // 不再设置通用token，避免冲突
      } else {
        // 清除所有token
        localStorage.removeItem('token')
        localStorage.removeItem('userToken')
        localStorage.removeItem('adminToken')
      }
    },

    // 设置加载状态
    SET_LOADING(state, loading) {
      state.loading = loading
    },

    // 设置页面标题
    SET_PAGE_TITLE(state, title) {
      state.pageTitle = title
      document.title = title
    },

    // 清除用户信息
    CLEAR_USER_INFO(state) {
      const wasAdmin = state.userInfo?.userRole === 'ADMIN'
      state.userInfo = null
      state.isLoggedIn = false
      state.token = null
      
      // 只清除当前角色相关的localStorage
      if (wasAdmin) {
        localStorage.removeItem('adminToken')
        localStorage.removeItem('adminUserInfo')
      } else {
        localStorage.removeItem('userToken')
        localStorage.removeItem('userUserInfo')
      }
      // 向后兼容：清除旧格式
      localStorage.removeItem('token')
      localStorage.removeItem('userInfo')
    },

    // 更新用户信息
    UPDATE_USER_INFO(state, updates) {
      if (state.userInfo) {
        state.userInfo = { ...state.userInfo, ...updates }
        // 根据用户角色使用不同的存储键
        const storageKey = state.userInfo.userRole === 'ADMIN' ? 'adminUserInfo' : 'userUserInfo'
        localStorage.setItem(storageKey, JSON.stringify(state.userInfo))
      }
    }
  },

  // 异步操作
  actions: {
    // 用户登录
    async login({ commit }, loginData) {
      try {
        commit('SET_LOADING', true)
        
        // 如果传入的是已经获取到的用户信息（管理员登录场景）
        if (loginData.userInfo) {
          const userInfo = loginData.userInfo
          commit('SET_USER_INFO', userInfo)
          commit('SET_TOKEN', userInfo.token)
          return { success: true, data: userInfo }
        }
        
        // 普通用户登录场景
        const response = await userApi.login(loginData)
        
        if (response.success) {
          const userInfo = response.data
          commit('SET_USER_INFO', userInfo)
          commit('SET_TOKEN', userInfo.token)
          
          return { success: true, data: userInfo }
        } else {
          return { success: false, message: response.message || '登录失败' }
        }
      } catch (error) {
        // 登录失败日志已移除
        return { success: false, message: error.message }
      } finally {
        commit('SET_LOADING', false)
      }
    },

    // 用户注册
    async register({ commit }, registerData) {
      try {
        commit('SET_LOADING', true)
        const response = await userApi.register(registerData)
        
        if (response.success) {
          const userInfo = response.data
          commit('SET_USER_INFO', userInfo)
          commit('SET_TOKEN', userInfo.token)
          
          return { success: true, data: userInfo }
        }
      } catch (error) {
        // 注册失败日志已移除
        return { success: false, message: error.message }
      } finally {
        commit('SET_LOADING', false)
      }
    },

    // 用户登出
    logout({ commit }) {
      commit('CLEAR_USER_INFO')
      commit('SET_PAGE_TITLE', '惠学阁')
    },

    // 初始化用户信息（从localStorage恢复）
    async initializeUser({ commit }, context = 'frontend') {
      let token, userInfoStr
      
      if (context === 'admin') {
        // 管理后台：读取管理员相关的存储
        token = localStorage.getItem('adminToken')
        userInfoStr = localStorage.getItem('adminUserInfo')
      } else {
        // 前台：读取用户相关的存储
        token = localStorage.getItem('userToken')
        userInfoStr = localStorage.getItem('userUserInfo')
      }
      
      // 向后兼容：如果没有找到新格式的存储，尝试读取旧格式
      if (!token && !userInfoStr) {
        token = localStorage.getItem('token')
        userInfoStr = localStorage.getItem('userInfo')
      }
      
      if (token && userInfoStr) {
        try {
          const userInfo = JSON.parse(userInfoStr)
          
          // 根据上下文决定是否显示用户信息
          if (context === 'admin') {
            // 管理后台：只显示管理员
            if (userInfo.role === 'ADMIN' || userInfo.userRole === 'ADMIN') {
              commit('SET_USER_INFO', userInfo)
              commit('SET_TOKEN', token)
              return { success: true, message: '管理员状态恢复成功' }
            } else {
              commit('CLEAR_USER_INFO')
              return { success: false, message: '当前存储的不是管理员账户' }
            }
          } else {
            // 前台：只显示普通用户
            if (userInfo.role === 'USER' || userInfo.userRole === 'USER') {
              commit('SET_USER_INFO', userInfo)
              commit('SET_TOKEN', token)
              return { success: true, message: '用户状态恢复成功' }
            } else {
              commit('CLEAR_USER_INFO')
              return { success: false, message: '当前存储的不是普通用户账户' }
            }
          }
        } catch (error) {
          // 恢复用户信息失败日志已移除
          commit('CLEAR_USER_INFO')
          return { success: false, message: '恢复用户信息失败：' + error.message }
        }
      }
      
      // 如果没有有效的用户信息，清除状态
      commit('CLEAR_USER_INFO')
      return { success: false, message: '没有找到有效的登录状态' }
    },

    // 获取用户信息
    async fetchUserProfile({ commit }) {
      try {
        const response = await userApi.getUserProfile()
        if (response.success) {
          commit('SET_USER_INFO', response.data)
          return { success: true, data: response.data }
        }
      } catch (error) {
        // 获取用户信息失败日志已移除
        return { success: false, message: error.message }
      }
    },

    // 更新用户信息
    async updateUserProfile({ commit }, userData) {
      try {
        commit('SET_LOADING', true)
        const response = await userApi.updateUserProfile(userData)
        
        if (response.success) {
          commit('UPDATE_USER_INFO', response.data)
          return { success: true, data: response.data }
        }
      } catch (error) {
        // 更新用户信息失败日志已移除
        return { success: false, message: error.message }
      } finally {
        commit('SET_LOADING', false)
      }
    },

    // 修改密码
    async changePassword({ commit }, passwordData) {
      try {
        commit('SET_LOADING', true)
        const response = await userApi.changePassword(passwordData)
        
        if (response.success) {
          return { success: true, message: response.message }
        }
      } catch (error) {
        // 修改密码失败日志已移除
        return { success: false, message: error.message }
      } finally {
        commit('SET_LOADING', false)
      }
    },

    // 验证token有效性
    async validateToken({ commit }) {
      try {
        const response = await userApi.validateToken()
        if (response.success) {
          return { success: true, data: response.data }
        }
      } catch (error) {
        // Token验证失败日志已移除
        commit('CLEAR_USER_INFO')
        return { success: false, message: error.message }
      }
    },

    // 自动验证并刷新用户状态
    async autoValidateUser({ commit, state }, context = 'frontend') {
      if (!state.token || !state.userInfo) {
        return { success: false, message: '没有有效的登录状态' }
      }

      try {
        // 根据上下文使用不同的验证接口
        let response;
        if (context === 'admin') {
          // 管理员使用专用的验证接口
          response = await userApi.validateAdminToken()
        } else {
          // 普通用户使用原有的验证接口
          response = await userApi.validateToken()
        }
        
        if (response.success) {
          // token有效，更新用户信息
          const validatedUserInfo = response.data
          
          // 检查角色是否匹配上下文
          if (context === 'admin') {
            if (validatedUserInfo.role !== 'ADMIN' && validatedUserInfo.userRole !== 'ADMIN') {
              commit('CLEAR_USER_INFO')
              return { success: false, message: '您不是管理员，无法访问管理后台' }
            }
          } else {
            if (validatedUserInfo.role === 'ADMIN' || validatedUserInfo.userRole === 'ADMIN') {
              commit('CLEAR_USER_INFO')
              return { success: false, message: '管理员请使用管理后台登录' }
            }
          }
          
          // 合并用户信息，保留token
          const updatedUserInfo = {
            ...state.userInfo,
            ...validatedUserInfo,
            token: state.token
          }
          
          commit('SET_USER_INFO', updatedUserInfo)
          return { success: true, data: updatedUserInfo }
        }
      } catch (error) {
        // 自动验证失败日志已移除
        // token无效，清除登录状态
        commit('CLEAR_USER_INFO')
        return { success: false, message: 'token已过期，请重新登录' }
      }
    },

    // 设置页面标题
    setPageTitle({ commit }, title) {
      commit('SET_PAGE_TITLE', `${title} - 惠学阁`)
    }
  },

  // 模块
  modules: {
    // 可以在这里添加其他模块
  }
})
